{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network implementation (TensorFlow).\n",
    "\n",
    "In this notebook, we will implement DQN with **experience replay** and **target networks**. Previous notebook had code in PyTorch and this notebook will replicate most of the same code using Tensorflow library.\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use $\\epsilon$-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update.\n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the $q(s,a)$ for all the actions in the state $s$. It is denoted as $ \\hat{q}(s_t, a_t; w_{t}) $, where $w_{t}$ is the weigths of the neural network that we learn as part of DQN learning.\n",
    "\n",
    "We use two networks, one target network with weight $w^-_t$ to get the max $q$-value of next state with best action denoted by $ \\max\\limits_a \\hat {q}(S_{t+1},a; w^{-}_{t}) $ and network with weights $w_t^-$ which we periodically updated from primary network $w_t$.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a;w^{-}_{t}) – \\hat{q}(S_t,A_t;w_t)] \\nabla \\hat{q}_{w_t}(S_t,A_t;w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values.\n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions `(current state, action, reward, next state)` in a buffer, where each sample is denoted as a tuple:\n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s'_{i}, done_{i})$$\n",
    "\n",
    "Subscript ($i$) denotes ith sample. We take $N$ samples from experience replay selecting randomly and update the weights. Subscript ($t$) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_{i},a';w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## uncomment and execute this cell to install all the the dependencies if running in Google Colab or Kaggle\n",
    "# !apt-get update \n",
    "# !apt-get install -y swig cmake ffmpeg freeglut3-dev xvfb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab or Kaggle\n",
    "\n",
    "## Uncomment and run for Colab\n",
    "# !git clone https://github.com/nsanghi/drl-2ed\n",
    "# %cd /content/drl-2ed \n",
    "# !pip install  -r requirements.txt\n",
    "# %cd chapter6\n",
    "\n",
    "\n",
    "## Uncomment and run for Kaggle\n",
    "# !git clone https://github.com/nsanghi/drl-2ed\n",
    "# %cd /kaggle/working/drl-2ed \n",
    "# !pip install  -r requirements.txt\n",
    "# %cd chapter6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and Rerun the cd command in case you were asked to restart the kernel and you followed that message\n",
    "## as after resart the kernel will again point back to root folder\n",
    "\n",
    "\n",
    "## Uncomment and run for Colab\n",
    "# %cd /content/drl-2ed \n",
    "# %cd chapter6\n",
    "\n",
    "\n",
    "## Uncomment and run for Kaggle\n",
    "# %cd /kaggle/working/drl-2ed \n",
    "# %cd chapter6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-05 06:01:59.205661: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-05 06:01:59.259383: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-05 06:01:59.259426: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-05 06:01:59.259447: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-05 06:01:59.268089: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-05 06:02:00.731166: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.layers import Dense, Flatten\n",
    "from tensorflow.keras import Model\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "from base64 import b64encode\n",
    "\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole. In another notebook we will run this on other environments like Atari games and a few others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    # increase time limit from 200/500 to 4000\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\", max_episode_steps=4000)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=123\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using tensorflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden layers with Relu activation and final layer being logits with dimension equal to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "\n",
    "        state_dim = state_shape[0]\n",
    "        self.model = tf.keras.models.Sequential()\n",
    "        self.model.add(tf.keras.Input(shape=(state_dim,)))\n",
    "        self.model.add(tf.keras.layers.Dense(256, activation='relu'))\n",
    "        self.model.add(tf.keras.layers.Dense(256, activation='relu'))\n",
    "        self.model.add(tf.keras.layers.Dense(n_actions))\n",
    "    \n",
    "    def __call__(self, state_t):\n",
    "        # pass the state at time t through the newrok to get Q(s,a)\n",
    "        qvalues = self.model(state_t)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        qvalues = self.model(states)\n",
    "        return qvalues.numpy()\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, 256)               1280      \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 256)               65792     \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 2)                 514       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 67586 (264.01 KB)\n",
      "Trainable params: 67586 (264.01 KB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "agent.model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s, _ = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues(np.array([s]))\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, terminated, truncated, _ = env.step(action)\n",
    "            reward += r\n",
    "            if terminated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon$-greedy) to sample from the environment and store the transitions `(s,a,r,s',done)` into a buffer. These samples are used multiple times in a learning making the process sample efficient.\n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues(np.array([s]))\n",
    "        a = agent.sample_actions(qvalues)[0]        \n",
    "        next_s, r, terminated, truncated, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        done = terminated or truncated\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if terminated:\n",
    "            s, _ = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "        \n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5)\n",
    "target_network.model.set_weights(agent.model.get_weights())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with DQN\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation:\n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}_{w_t}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_{w_t} L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}_{w_t}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',a';w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network.\n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max\\limits_{a'} \\hat{q}(s'_i,a';w^-_t)$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$\n",
    "w_{t+1} \\leftarrow w_t - \\alpha . \\nabla_{w_t}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_td_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99):\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent(states)\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use target network\n",
    "    predicted_next_qvalues = target_network(next_states)\n",
    "    \n",
    "    # select q-values for chosen actions\n",
    "    row_indices= tf.range(len(actions))\n",
    "    indices = tf.transpose([row_indices, actions])\n",
    "    predicted_qvalues_for_actions = tf.gather_nd(predicted_qvalues, indices)\n",
    "    \n",
    "\n",
    "    # compute Qmax(next_states, actions) using predicted next q-values\n",
    "    next_state_values = tf.reduce_max(predicted_next_qvalues, axis=1)\n",
    "\n",
    "    # compute \"target q-values\" \n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = tf.keras.losses.MSE(target_qvalues_for_actions, predicted_qvalues_for_actions)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set a seed\n",
    "seed = 13\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "tf.random.set_seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set up Environment and Policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup env and agent and target networks\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state, _ = env.reset(seed=seed)\n",
    "\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1)\n",
    "target_network.model.set_weights(agent.model.get_weights())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Populate Experience Replay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    }
   ],
   "source": [
    "# let us fill experience replay with some samples using full random policy\n",
    "exp_replay = ReplayBuffer(10**4)\n",
    "for i in range(100):\n",
    "    play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "    if len(exp_replay) == 10**4:\n",
    "        break\n",
    "print(len(exp_replay))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 5 * 10**4\n",
    "\n",
    "#init Optimizer\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=1e-4)\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup spme frequency for loggind and updating target network\n",
    "loss_freq = 20\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_rw_history = []\n",
    "td_loss_history = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████| 50001/50001 [24:29<00:00, 34.04it/s]\n"
     ]
    }
   ],
   "source": [
    "state, _ = env.reset()\n",
    "for step in trange(total_steps + 1):\n",
    "    \n",
    "    # reduce exploration as we progress\n",
    "    agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "    # take timesteps_per_epoch and update experience replay buffer\n",
    "    _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "    # train by sampling batch_size of data from experience replay\n",
    "    states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "    \n",
    "    with tf.GradientTape() as tape:\n",
    "        # loss = <compute TD loss>\n",
    "        loss = compute_td_loss(agent, target_network, \n",
    "                               states, actions, rewards, next_states, done_flags,                  \n",
    "                               gamma=0.99)\n",
    "\n",
    "    gradients = tape.gradient(loss, agent.model.trainable_variables)\n",
    "    clipped_grads = [tf.clip_by_norm(g, max_grad_norm) for g in gradients]\n",
    "    optimizer.apply_gradients(zip(clipped_grads, agent.model.trainable_variables))\n",
    "\n",
    "\n",
    "    if step % loss_freq == 0:\n",
    "        td_loss_history.append(loss.numpy())\n",
    "\n",
    "    if step % refresh_target_network_freq == 0:\n",
    "        # Load agent weights into target_network\n",
    "        target_network.model.set_weights(agent.model.get_weights())\n",
    "\n",
    "    if step % eval_freq == 0:\n",
    "        # eval the agent\n",
    "        mean_rw_history.append(evaluate(\n",
    "            make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "        )\n",
    "\n",
    "        clear_output(True)\n",
    "        print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "              (len(exp_replay), agent.epsilon))\n",
    "\n",
    "        plt.figure(figsize=[16, 5])\n",
    "        plt.subplot(1, 2, 1)\n",
    "        plt.title(\"Mean return per episode\")\n",
    "        plt.plot(mean_rw_history)\n",
    "        plt.grid()\n",
    "\n",
    "        assert not np.isnan(td_loss_history[-1])\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.title(\"TD loss history (smoothened)\")\n",
    "        plt.plot(smoothen(td_loss_history))\n",
    "        plt.grid()\n",
    "\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 332.4\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Record and Play a video of trained agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action = np.argmax(agent.get_qvalues(obs),axis=-1)\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/vanilla/videos/tf/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/vanilla/videos/tf/DQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/vanilla/videos/tf/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter6/logs/6_a/vanilla/videos/tf/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/6_a/vanilla/videos/tf/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Important Notes\n",
    "\n",
    "We cannot use stablebaseline3 (SB3) or SB#-Zoo with Tensorflow as SB3 and SB3-Zoo work only with PyTorch. In order to use it alongwith Tensorflow you can either switch to older version of Stablebaselines i.e. [stablebaselines2(SB2)](https://stable-baselines.readthedocs.io/en/master/guide/install.html). However the older version has two issues, it does not work with the newer Gymnasium library and it still depends on the older Gym library. In addition, SB2 works with older versions of Tensorflow only. \n",
    "\n",
    "There is another option, that of using [Tensorflow Agents](https://www.tensorflow.org/agents). This again works with the older gym library and does not have support from Gymnasium.\n",
    "\n",
    "My advice for the learner would be to stick to PyTorch ecosystem while learning. As and when you work on a RL project which specifically needs TensorFlow backend, you could look at the above options. In any case, you would have your own environment which can be implemented on top of the Gym interface. In that case you do not need to bother about the newer Gymnasium interface."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks. We can improve this agent with many tricks. As we go along, we will be implementing many of these variants."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
